// 版权归Go作者所有。版权所有。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

// 软件包socktest为套接字测试提供实用程序。
package socktest

import (
	"fmt"
	"sync"
)

// 开关表示套接字系统的调用路径点开关
// 调用。
type Switch struct {
	once sync.Once

	fmu   sync.RWMutex
	fltab map[FilterType]Filter

	smu   sync.RWMutex
	sotab Sockets
	stats stats
}

func (sw *Switch) init() {
	sw.fltab = make(map[FilterType]Filter)
	sw.sotab = make(Sockets)
	sw.stats = make(stats)
}

// Stats返回每个cookie套接字的统计信息列表。
func (sw *Switch) Stats() []Stat {
	var st []Stat
	sw.smu.RLock()
	for _, s := range sw.stats {
		ns := *s
		st = append(st, ns)
	}
	sw.smu.RUnlock()
	return st
}

// 套接字返回套接字描述符到套接字状态的映射。
func (sw *Switch) Sockets() Sockets {
	sw.smu.RLock()
	tab := make(Sockets, len(sw.sotab))
	for i, s := range sw.sotab {
		tab[i] = s
	}
	sw.smu.RUnlock()
	return tab
}

// Cookie表示套接字的3元组；地址系列，套接字
// 类型和协议号。
type Cookie uint64

// Family返回一个地址Family。
func (c Cookie) Family() int { return int(c >> 48) }

// Type返回套接字类型。
func (c Cookie) Type() int { return int(c << 16 >> 32) }

// 协议返回协议号。
func (c Cookie) Protocol() int { return int(c & 0xff) }

func cookie(family, sotype, proto int) Cookie {
	return Cookie(family)<<48 | Cookie(sotype)&0xffffffff<<16 | Cookie(proto)&0xff
}

// 状态表示套接字的状态。
type Status struct {
	Cookie    Cookie
	Err       error // socket系统调用的错误状态
	SocketErr error // socket by SO_error 
}

func (so Status) String() string {
	return fmt.Sprintf("(%s, %s, %s): syscallerr=%v socketerr=%v", familyString(so.Cookie.Family()), typeString(so.Cookie.Type()), protocolString(so.Cookie.Protocol()), so.Err, so.SocketErr)
}

// 一个Stat表示每个cookie套接字的统计信息。
type Stat struct {
	Family   int // 地址系列
	Type     int // 套接字类型
	Protocol int // 协议号

	Opened    uint64 // 打开的套接字数
	Connected uint64 // 连接的套接字数
	Listened  uint64 // 侦听的套接字数
	Accepted  uint64 // 接受的套接字数
	Closed    uint64 // 关闭的套接字数

	OpenFailed    uint64 // 打开失败的套接字数
	ConnectFailed uint64 // 连接失败的套接字数
	ListenFailed  uint64 // 侦听失败的套接字数
	AcceptFailed  uint64 // 接受失败的套接字数
	CloseFailed   uint64 // 关闭失败的套接字数
}

func (st Stat) String() string {
	return fmt.Sprintf("(%s, %s, %s): opened=%d connected=%d listened=%d accepted=%d closed=%d openfailed=%d connectfailed=%d listenfailed=%d acceptfailed=%d closefailed=%d", familyString(st.Family), typeString(st.Type), protocolString(st.Protocol), st.Opened, st.Connected, st.Listened, st.Accepted, st.Closed, st.OpenFailed, st.ConnectFailed, st.ListenFailed, st.AcceptFailed, st.CloseFailed)
}

type stats map[Cookie]*Stat

func (st stats) getLocked(c Cookie) *Stat {
	s, ok := st[c]
	if !ok {
		s = &Stat{Family: c.Family(), Type: c.Type(), Protocol: c.Protocol()}
		st[c] = s
	}
	return s
}

// 过滤器类型表示过滤器类型。
type FilterType int

const (
	FilterSocket        FilterType = iota // 对于套接字
	FilterConnect                         // 对于连接或ConnectEx 
	FilterListen                          // 对于侦听
	FilterAccept                          // 对于接受、接受4或接受Ex 
	FilterGetsockoptInt                   // 对于GetsockoptInt 
	FilterClose                           // 对于关闭或关闭套接字
)

// 筛选器表示套接字系统调用筛选器。
// 
// 仅在系统调用内部表中包含
// 项的套接字之前执行。
// 如果过滤器返回非nil错误，系统调用
// 的执行将被取消，系统调用函数返回非nil 
// 错误。
// 在执行系统调用后，返回一个非零的AfterFilter进行过滤。
type Filter func(*Status) (AfterFilter, error)

func (f Filter) apply(st *Status) (AfterFilter, error) {
	if f == nil {
		return nil, nil
	}
	return f(st)
}

// 后过滤器表示系统调用执行后的套接字系统调用过滤器。
// 
// 仅在系统调用内部表中包含
// 项的套接字后执行。
// 如果过滤器返回非零错误，则系统调用函数
// 返回非零错误。
type AfterFilter func(*Status) error

func (f AfterFilter) apply(st *Status) error {
	if f == nil {
		return nil
	}
	return f(st)
}

// Set为过滤器类型t部署套接字系统调用过滤器f。
func (sw *Switch) Set(t FilterType, f Filter) {
	sw.once.Do(sw.init)
	sw.fmu.Lock()
	sw.fltab[t] = f
	sw.fmu.Unlock()
}
